# uncompyle6 version 3.2.3
# Python bytecode 3.6 (3379)
# Decompiled from: Python 3.6.8 |Anaconda custom (64-bit)| (default, Feb 21 2019, 18:30:04) [MSC v.1916 64 bit (AMD64)]
# Embedded file name: site-packages\PyInstaller\utils\win32\winmanifest.py
"""
Create, parse and write MS Windows Manifest files.
Find files which are part of an assembly, by searching shared and
private assemblies.
Update or add manifest resources in Win32 PE files.

Commandline usage:
winmanifest.py <dstpath> <xmlpath>
Updates or adds manifest <xmlpath> as resource in Win32 PE file <dstpath>.
"""
import os
from glob import glob
import hashlib, sys, xml
from xml.dom import Node, minidom
from xml.dom.minidom import Document, Element
from PyInstaller import compat
from PyInstaller.compat import architecture, string_types
from PyInstaller import log as logging
from PyInstaller.utils.win32 import winresource

logger = logging.getLogger(__name__)
LANGUAGE_NEUTRAL_NT5 = "x-ww"
LANGUAGE_NEUTRAL_NT6 = "none"
RT_MANIFEST = 24
Document.aChild = Document.appendChild
Document.cE = Document.createElement
Document.cT = Document.createTextNode
Document.getEByTN = Document.getElementsByTagName
Element.aChild = Element.appendChild
Element.getA = Element.getAttribute
Element.getEByTN = Element.getElementsByTagName
Element.remA = Element.removeAttribute
Element.setA = Element.setAttribute


def getChildElementsByTagName(self, tagName):
    """ Return child elements of type tagName if found, else [] """
    result = []
    for child in self.childNodes:
        if isinstance(child, Element):
            if child.tagName == tagName:
                result.append(child)

    return result


def getFirstChildElementByTagName(self, tagName):
    """ Return the first element of type tagName if found, else None """
    for child in self.childNodes:
        if isinstance(child, Element):
            if child.tagName == tagName:
                return child


Document.getCEByTN = getChildElementsByTagName
Document.getFCEByTN = getFirstChildElementByTagName
Element.getCEByTN = getChildElementsByTagName
Element.getFCEByTN = getFirstChildElementByTagName


class _Dummy:
    pass


if winresource:
    _File = winresource.File
else:
    _File = _Dummy


class File(_File):
    """ A file referenced by an assembly inside a manifest. """

    def __init__(
        self,
        filename="",
        hashalg=None,
        hash=None,
        comClasses=None,
        typelibs=None,
        comInterfaceProxyStubs=None,
        windowClasses=None,
    ):
        if winresource:
            winresource.File.__init__(self, filename)
        else:
            self.filename = filename
        self.name = os.path.basename(filename)
        if hashalg:
            self.hashalg = hashalg.upper()
        else:
            self.hashalg = None
        if os.path.isfile(filename):
            pass
        if hashalg:
            if hashlib:
                if hasattr(hashlib, hashalg.lower()):
                    self.calc_hash()
                self.hash = hash
            self.comClasses = comClasses or []
            self.typelibs = typelibs or []
            self.comInterfaceProxyStubs = comInterfaceProxyStubs or []
            self.windowClasses = windowClasses or []

    def calc_hash(self, hashalg=None):
        """
        Calculate the hash of the file.
        
        Will be called automatically from the constructor if the file exists
        and hashalg is given (and supported), but may also be called manually
        e.g. to update the hash if the file has changed.
        
        """
        fd = open(self.filename, "rb")
        buf = fd.read()
        fd.close()
        if hashalg:
            self.hashalg = hashalg.upper()
        self.hash = getattr(hashlib, self.hashalg.lower())(buf).hexdigest()

    def find(self, searchpath):
        logger.info("Searching for file %s", self.name)
        fn = os.path.join(searchpath, self.name)
        if os.path.isfile(fn):
            logger.info("Found file %s", fn)
            return fn
        else:
            logger.warning("No such file %s", fn)
            return


class InvalidManifestError(Exception):
    pass


class ManifestXMLParseError(InvalidManifestError):
    pass


class Manifest(object):
    """
    Manifest constructor.
    
    To build a basic manifest for your application:
      mf = Manifest(type='win32', name='YourAppName', language='*',
                    processorArchitecture='x86', version=[1, 0, 0, 0])
    
    To write the XML to a manifest file:
      mf.writexml("YourAppName.exe.manifest")
    or
      mf.writeprettyxml("YourAppName.exe.manifest")
    
    """

    def __init__(
        self,
        manifestVersion=None,
        noInheritable=False,
        noInherit=False,
        type_=None,
        name=None,
        language=None,
        processorArchitecture=None,
        version=None,
        publicKeyToken=None,
        description=None,
        requestedExecutionLevel=None,
        uiAccess=None,
        dependentAssemblies=None,
        files=None,
        comInterfaceExternalProxyStubs=None,
    ):
        self.filename = None
        self.optional = None
        self.manifestType = "assembly"
        self.manifestVersion = manifestVersion or [1, 0]
        self.noInheritable = noInheritable
        self.noInherit = noInherit
        self.type = type_
        self.name = name
        self.language = language
        self.processorArchitecture = processorArchitecture
        self.version = version
        self.publicKeyToken = publicKeyToken
        self.applyPublisherPolicy = None
        self.description = None
        self.requestedExecutionLevel = requestedExecutionLevel
        self.uiAccess = uiAccess
        self.dependentAssemblies = dependentAssemblies or []
        self.bindingRedirects = []
        self.files = files or []
        self.comInterfaceExternalProxyStubs = comInterfaceExternalProxyStubs or []

    def __eq__(self, other):
        if isinstance(other, Manifest):
            return self.toxml() == other.toxml()
        elif isinstance(other, string_types):
            return self.toxml() == other
        else:
            return False

    def __ne__(self, other):
        return not self.__eq__(other)

    def __repr__(self):
        return repr(self.toxml())

    def add_dependent_assembly(
        self,
        manifestVersion=None,
        noInheritable=False,
        noInherit=False,
        type_=None,
        name=None,
        language=None,
        processorArchitecture=None,
        version=None,
        publicKeyToken=None,
        description=None,
        requestedExecutionLevel=None,
        uiAccess=None,
        dependentAssemblies=None,
        files=None,
        comInterfaceExternalProxyStubs=None,
    ):
        """
        Shortcut for self.dependentAssemblies.append(Manifest(*args, **kwargs))
        """
        self.dependentAssemblies.append(
            Manifest(
                manifestVersion,
                noInheritable,
                noInherit,
                type_,
                name,
                language,
                processorArchitecture,
                version,
                publicKeyToken,
                description,
                requestedExecutionLevel,
                uiAccess,
                dependentAssemblies,
                files,
                comInterfaceExternalProxyStubs,
            )
        )
        if self.filename:
            self.dependentAssemblies[-1].filename = (":").join((self.filename, name))

    def add_file(
        self,
        name="",
        hashalg="",
        hash="",
        comClasses=None,
        typelibs=None,
        comInterfaceProxyStubs=None,
        windowClasses=None,
    ):
        """ Shortcut for manifest.files.append """
        self.files.append(
            File(
                name,
                hashalg,
                hash,
                comClasses,
                typelibs,
                comInterfaceProxyStubs,
                windowClasses,
            )
        )

    @classmethod
    def get_winsxs_dir(cls):
        return os.path.join(compat.getenv("SystemRoot"), "WinSxS")

    @classmethod
    def get_manifest_dir(cls):
        winsxs = cls.get_winsxs_dir()
        if not os.path.isdir(winsxs):
            logger.warning("No such dir %s", winsxs)
        manifests = os.path.join(winsxs, "Manifests")
        if not os.path.isdir(manifests):
            logger.warning("No such dir %s", manifests)
        return manifests

    @classmethod
    def get_policy_dir(cls):
        winsxs = os.path.join(compat.getenv("SystemRoot"), "WinSxS")
        if sys.getwindowsversion() < (6,):
            pcfiles = os.path.join(winsxs, "Policies")
            if not os.path.isdir(pcfiles):
                logger.warning("No such dir %s", pcfiles)
            else:
                pcfiles = cls.get_manifest_dir()
            return pcfiles

    def get_policy_redirect(self, language=None, version=None):
        redirected = False
        pcfiles = self.get_policy_dir()
        if version is None:
            version = self.version
        if language is None:
            language = self.language
        if os.path.isdir(pcfiles):
            logger.debug(
                "Searching for publisher configuration %s ...",
                self.getpolicyid(True, language=language),
            )
            if sys.getwindowsversion() < (6,):
                policies = os.path.join(
                    pcfiles, (self.getpolicyid(True, language=language)) + ".policy"
                )
            else:
                policies = os.path.join(
                    pcfiles, (self.getpolicyid(True, language=language)) + ".manifest"
                )
            for manifestpth in glob(policies):
                if not os.path.isfile(manifestpth):
                    logger.warning("Not a file %s", manifestpth)
                    continue
                    logger.info("Found %s", manifestpth)
                    try:
                        policy = ManifestFromXMLFile(manifestpth)
                    except Exception:
                        logger.error("Could not parse file %s", manifestpth, exc_info=1)

                    logger.debug("Checking publisher policy for binding redirects")
                    for assembly in policy.dependentAssemblies:
                        if not not assembly.same_id(self, True):
                            if assembly.optional:
                                pass
                            else:
                                for redirect in assembly.bindingRedirects:
                                    old = ("-").join(
                                        [
                                            (".").join([str(i) for i in part])
                                            for part in redirect[0]
                                        ]
                                    )
                                    new = (".").join([str(i) for i in redirect[1]])
                                    logger.debug(
                                        "Found redirect for version(s) %s -> %s",
                                        old,
                                        new,
                                    )
                                    if version >= redirect[0][0]:
                                        if version <= redirect[0][-1]:
                                            if version != redirect[1]:
                                                logger.debug(
                                                    "Applying redirect %s -> %s",
                                                    (".").join(
                                                        [str(i) for i in version]
                                                    ),
                                                    new,
                                                )
                                                version = redirect[1]
                                                redirected = True

            if not redirected:
                logger.debug("Publisher configuration not used")
        return version

    def find_files(self, ignore_policies=True):
        """ Search shared and private assemblies and return a list of files.
        
        If any files are not found, return an empty list.
        
        IMPORTANT NOTE: On some Windows systems, the dependency listed in the manifest
        will not actually be present, and finding its files will fail. This is because
        a newer version of the dependency is installed, and the manifest's dependency
        is being redirected to a newer version. To properly bundle the newer version of
        the assembly, you need to find the newer version by setting
        ignore_policies=False, and then either create a .config file for each bundled
        assembly, or modify each bundled assembly to point to the newer version.
        
        This is important because Python 2.7's app manifest depends on version 21022
        of the VC90 assembly, but the Python 2.7.9 installer will install version
        30729 of the assembly along with a policy file that enacts the version redirect.
        
        """
        files = []
        languages = []
        if self.language not in (None, "", "*", "neutral"):
            languages.append(self.getlanguage())
            if "-" in self.language:
                languages.append(self.language.split("-")[0])
            if self.language not in ("en-us", "en"):
                languages.append("en-us")
            if self.language != "en":
                languages.append("en")
        languages.append(self.getlanguage("*"))
        manifests = self.get_manifest_dir()
        winsxs = self.get_winsxs_dir()
        for language in languages:
            version = self.version
            if not ignore_policies:
                if version:
                    version = self.get_policy_redirect(language, version)
            paths = []
            if os.path.isdir(manifests):
                paths.extend(
                    glob(
                        os.path.join(
                            manifests,
                            (self.getid(language=language, version=version))
                            + "_*.manifest",
                        )
                    )
                )
            if self.filename:
                dirnm = os.path.dirname(self.filename)
                if language in (LANGUAGE_NEUTRAL_NT5, LANGUAGE_NEUTRAL_NT6):
                    for ext in (".dll", ".manifest"):
                        paths.extend(glob(os.path.join(dirnm, self.name + ext)))
                        paths.extend(
                            glob(os.path.join(dirnm, self.name, self.name + ext))
                        )

                else:
                    for ext in (".dll", ".manifest"):
                        paths.extend(
                            glob(os.path.join(dirnm, language, self.name + ext))
                        )

                    for ext in (".dll", ".manifest"):
                        paths.extend(
                            glob(
                                os.path.join(
                                    dirnm, language, self.name, self.name + ext
                                )
                            )
                        )

                logger.info(
                    "Searching for assembly %s ...",
                    self.getid(language=language, version=version),
                )
                for manifestpth in paths:
                    if not os.path.isfile(manifestpth):
                        logger.warning("Not a file %s", manifestpth)
                        continue
                    assemblynm = os.path.basename(os.path.splitext(manifestpth)[0])
                    try:
                        if manifestpth.endswith(".dll"):
                            logger.info("Found manifest in %s", manifestpth)
                            manifest = ManifestFromResFile(manifestpth, [1])
                        else:
                            logger.info("Found manifest %s", manifestpth)
                            manifest = ManifestFromXMLFile(manifestpth)
                    except Exception:
                        logger.error(
                            "Could not parse manifest %s", manifestpth, exc_info=1
                        )
                    else:
                        if manifestpth.startswith(winsxs):
                            assemblydir = os.path.join(winsxs, assemblynm)
                            if not os.path.isdir(assemblydir):
                                logger.warning("No such dir %s", assemblydir)
                                logger.warning("Assembly incomplete")
                                return []
                        else:
                            assemblydir = os.path.dirname(manifestpth)
                        files.append(manifestpth)
                        for file_ in self.files or manifest.files:
                            fn = file_.find(assemblydir)
                            if fn:
                                files.append(fn)
                            else:
                                logger.warning("Assembly incomplete")
                                return []

                    return files

        logger.warning("Assembly not found")
        return []

    def getid(self, language=None, version=None):
        """
        Return an identification string which uniquely names a manifest.
        
        This string is a combination of the manifest's processorArchitecture,
        name, publicKeyToken, version and language.
        
        Arguments:
        version (tuple or list of integers) - If version is given, use it
                                              instead of the manifest's
                                              version.
        
        """
        if not self.name:
            logger.warning("Assembly metadata incomplete")
            return ""
        else:
            id = []
            if self.processorArchitecture:
                id.append(self.processorArchitecture)
            id.append(self.name)
            if self.publicKeyToken:
                id.append(self.publicKeyToken)
            if version or self.version:
                id.append((".").join([str(i) for i in version or self.version]))
            if not language:
                language = self.getlanguage()
            if language:
                id.append(language)
            return ("_").join(id)

    def getlanguage(self, language=None, windowsversion=None):
        """
        Get and return the manifest's language as string.
        
        Can be either language-culture e.g. 'en-us' or a string indicating
        language neutrality, e.g. 'x-ww' on Windows XP or 'none' on Vista
        and later.
        
        """
        if not language:
            language = self.language
        if language in (None, "", "*", "neutral"):
            return (LANGUAGE_NEUTRAL_NT5, LANGUAGE_NEUTRAL_NT6)[
                (windowsversion or sys.getwindowsversion()) >= (6,)
            ]
        else:
            return language

    def getpolicyid(self, fuzzy=True, language=None, windowsversion=None):
        """
        Return an identification string which can be used to find a policy.
        
        This string is a combination of the manifest's processorArchitecture,
        major and minor version, name, publicKeyToken and language.
        
        Arguments:
        fuzzy (boolean)             - If False, insert the full version in
                                      the id string. Default is True (omit).
        windowsversion              - If not specified (or None), default to
        (tuple or list of integers)   sys.getwindowsversion().
        
        """
        if not self.name:
            logger.warning("Assembly metadata incomplete")
            return ""
        else:
            id = []
            if self.processorArchitecture:
                id.append(self.processorArchitecture)
            name = []
            name.append("policy")
            if self.version:
                name.append(str(self.version[0]))
                name.append(str(self.version[1]))
            name.append(self.name)
            id.append((".").join(name))
            if self.publicKeyToken:
                id.append(self.publicKeyToken)
            if self.version:
                if (windowsversion or sys.getwindowsversion()) >= (6,):
                    if fuzzy:
                        id.append("*")
                    else:
                        id.append((".").join([str(i) for i in self.version]))
                    if not language:
                        language = self.getlanguage(windowsversion=windowsversion)
                    if language:
                        id.append(language)
                    id.append("*")
                    id = ("_").join(id)
                    if self.version:
                        if (windowsversion or sys.getwindowsversion()) < (6,):
                            if fuzzy:
                                id = os.path.join(id, "*")
                            else:
                                id = os.path.join(
                                    id, (".").join([str(i) for i in self.version])
                                )
            return id

    def load_dom(self, domtree, initialize=True):
        """
        Load manifest from DOM tree.
        
        If initialize is True (default), reset existing attributes first.
        
        """
        if domtree.nodeType == Node.DOCUMENT_NODE:
            rootElement = domtree.documentElement
        else:
            if domtree.nodeType == Node.ELEMENT_NODE:
                rootElement = domtree
            else:
                raise InvalidManifestError(
                    "Invalid root element node type "
                    + str(rootElement.nodeType)
                    + " - has to be one of (DOCUMENT_NODE, ELEMENT_NODE)"
                )
            allowed_names = (
                "assembly",
                "assemblyBinding",
                "configuration",
                "dependentAssembly",
            )
            if rootElement.tagName not in allowed_names:
                raise InvalidManifestError(
                    "Invalid root element <%s> - has to be one of <%s>"
                    % (rootElement.tagName, (">, <").join(allowed_names))
                )
            if rootElement.tagName == "configuration":
                for windows in rootElement.getCEByTN("windows"):
                    for assemblyBinding in windows.getCEByTN("assemblyBinding"):
                        self.load_dom(assemblyBinding, initialize)

            else:
                if initialize:
                    self.__init__()
                self.manifestType = rootElement.tagName
                self.manifestVersion = [
                    int(i)
                    for i in (rootElement.getA("manifestVersion") or "1.0").split(".")
                ]
                self.noInheritable = bool(rootElement.getFCEByTN("noInheritable"))
                self.noInherit = bool(rootElement.getFCEByTN("noInherit"))
                for assemblyIdentity in rootElement.getCEByTN("assemblyIdentity"):
                    self.type = assemblyIdentity.getA("type") or None
                    self.name = assemblyIdentity.getA("name") or None
                    self.language = assemblyIdentity.getA("language") or None
                    self.processorArchitecture = (
                        assemblyIdentity.getA("processorArchitecture") or None
                    )
                    version = assemblyIdentity.getA("version")
                    if version:
                        self.version = tuple((int(i) for i in version.split(".")))
                    self.publicKeyToken = (
                        assemblyIdentity.getA("publicKeyToken") or None
                    )

                for publisherPolicy in rootElement.getCEByTN("publisherPolicy"):
                    self.applyPublisherPolicy = (
                        publisherPolicy.getA("apply") or ""
                    ).lower() == "yes"

                for description in rootElement.getCEByTN("description"):
                    if description.firstChild:
                        self.description = description.firstChild.wholeText

                for trustInfo in rootElement.getCEByTN("trustInfo"):
                    for security in trustInfo.getCEByTN("security"):
                        for reqPriv in security.getCEByTN("requestedPrivileges"):
                            for reqExeLev in reqPriv.getCEByTN(
                                "requestedExecutionLevel"
                            ):
                                self.requestedExecutionLevel = reqExeLev.getA("level")
                                self.uiAccess = (
                                    reqExeLev.getA("uiAccess") or ""
                                ).lower() == "true"

                if rootElement.tagName == "assemblyBinding":
                    dependencies = [rootElement]
                else:
                    dependencies = rootElement.getCEByTN("dependency")
                for dependency in dependencies:
                    for dependentAssembly in dependency.getCEByTN("dependentAssembly"):
                        manifest = ManifestFromDOM(dependentAssembly)
                        if not manifest.name:
                            continue
                        manifest.optional = (
                            dependency.getA("optional") or ""
                        ).lower() == "yes"
                        self.dependentAssemblies.append(manifest)
                        if self.filename:
                            self.dependentAssemblies[-1].filename = (":").join(
                                (self.filename, manifest.name)
                            )

                for bindingRedirect in rootElement.getCEByTN("bindingRedirect"):
                    oldVersion = tuple(
                        (
                            tuple((int(i) for i in part.split(".")))
                            for part in bindingRedirect.getA("oldVersion").split("-")
                        )
                    )
                    newVersion = tuple(
                        (int(i) for i in bindingRedirect.getA("newVersion").split("."))
                    )
                    self.bindingRedirects.append((oldVersion, newVersion))

                for file_ in rootElement.getCEByTN("file"):
                    self.add_file(
                        name=file_.getA("name"),
                        hashalg=file_.getA("hashalg"),
                        hash=file_.getA("hash"),
                    )

    def parse(self, filename_or_file, initialize=True):
        """ Load manifest from file or file object """
        if isinstance(filename_or_file, string_types):
            filename = filename_or_file
        else:
            filename = filename_or_file.name
        try:
            domtree = minidom.parse(filename_or_file)
        except xml.parsers.expat.ExpatError as e:
            args = [e.args[0]]
            args.insert(0, '\n  File "%s"\n   ' % filename)
            raise ManifestXMLParseError((" ").join([str(arg) for arg in args]))

        if initialize:
            self.__init__()
        self.filename = filename
        self.load_dom(domtree, False)

    def parse_string(self, xmlstr, initialize=True):
        """ Load manifest from XML string """
        try:
            domtree = minidom.parseString(xmlstr)
        except xml.parsers.expat.ExpatError as e:
            raise ManifestXMLParseError(e)

        self.load_dom(domtree, initialize)

    def same_id(self, manifest, skip_version_check=False):
        """
        Return a bool indicating if another manifest has the same identitiy.
        
        This is done by comparing language, name, processorArchitecture,
        publicKeyToken, type and version.
        
        """
        if skip_version_check:
            version_check = True
        else:
            version_check = self.version == manifest.version
        return (
            self.language == manifest.language
            and self.name == manifest.name
            and self.processorArchitecture == manifest.processorArchitecture
            and self.publicKeyToken == manifest.publicKeyToken
            and self.type == manifest.type
            and version_check
        )

    def todom(self):
        """ Return the manifest as DOM tree """
        doc = Document()
        docE = doc.cE(self.manifestType)
        if self.manifestType == "assemblyBinding":
            cfg = doc.cE("configuration")
            win = doc.cE("windows")
            win.aChild(docE)
            cfg.aChild(win)
            doc.aChild(cfg)
        else:
            doc.aChild(docE)
        if self.manifestType != "dependentAssembly":
            docE.setA("xmlns", "urn:schemas-microsoft-com:asm.v1")
            if self.manifestType != "assemblyBinding":
                docE.setA(
                    "manifestVersion",
                    (".").join([str(i) for i in self.manifestVersion]),
                )
        if self.noInheritable:
            docE.aChild(doc.cE("noInheritable"))
        if self.noInherit:
            docE.aChild(doc.cE("noInherit"))
        aId = doc.cE("assemblyIdentity")
        if self.type:
            aId.setAttribute("type", self.type)
        if self.name:
            aId.setAttribute("name", self.name)
        if self.language:
            aId.setAttribute("language", self.language)
        if self.processorArchitecture:
            aId.setAttribute("processorArchitecture", self.processorArchitecture)
        if self.version:
            aId.setAttribute("version", (".").join([str(i) for i in self.version]))
        if self.publicKeyToken:
            aId.setAttribute("publicKeyToken", self.publicKeyToken)
        if aId.hasAttributes():
            docE.aChild(aId)
        else:
            aId.unlink()
        if self.applyPublisherPolicy != None:
            ppE = doc.cE("publisherPolicy")
            if self.applyPublisherPolicy:
                ppE.setA("apply", "yes")
            else:
                ppE.setA("apply", "no")
            docE.aChild(ppE)
        if self.description:
            descE = doc.cE("description")
            descE.aChild(doc.cT(self.description))
            docE.aChild(descE)
        if self.requestedExecutionLevel in (
            "asInvoker",
            "highestAvailable",
            "requireAdministrator",
        ):
            tE = doc.cE("trustInfo")
            tE.setA("xmlns", "urn:schemas-microsoft-com:asm.v3")
            sE = doc.cE("security")
            rpE = doc.cE("requestedPrivileges")
            relE = doc.cE("requestedExecutionLevel")
            relE.setA("level", self.requestedExecutionLevel)
            if self.uiAccess:
                relE.setA("uiAccess", "true")
            else:
                relE.setA("uiAccess", "false")
            rpE.aChild(relE)
            sE.aChild(rpE)
            tE.aChild(sE)
            docE.aChild(tE)
        if self.dependentAssemblies:
            for assembly in self.dependentAssemblies:
                if self.manifestType != "assemblyBinding":
                    dE = doc.cE("dependency")
                    if assembly.optional:
                        dE.setAttribute("optional", "yes")
                daE = doc.cE("dependentAssembly")
                adom = assembly.todom()
                for child in adom.documentElement.childNodes:
                    daE.aChild(child.cloneNode(False))

                adom.unlink()
                if self.manifestType != "assemblyBinding":
                    dE.aChild(daE)
                    docE.aChild(dE)
                else:
                    docE.aChild(daE)

        if self.bindingRedirects:
            for bindingRedirect in self.bindingRedirects:
                brE = doc.cE("bindingRedirect")
                brE.setAttribute(
                    "oldVersion",
                    ("-").join(
                        [
                            (".").join([str(i) for i in part])
                            for part in bindingRedirect[0]
                        ]
                    ),
                )
                brE.setAttribute(
                    "newVersion", (".").join([str(i) for i in bindingRedirect[1]])
                )
                docE.aChild(brE)

        if self.files:
            for file_ in self.files:
                fE = doc.cE("file")
                for attr in ("name", "hashalg", "hash"):
                    val = getattr(file_, attr)
                    if val:
                        fE.setA(attr, val)

                docE.aChild(fE)

        cE = doc.cE("compatibility")
        cE.setAttribute("xmlns", "urn:schemas-microsoft-com:compatibility.v1")
        caE = doc.cE("application")
        supportedOS_guids = {
            "Vista": "{e2011457-1546-43c5-a5fe-008deee3d3f0}",
            "7": "{35138b9a-5d96-4fbd-8e2d-a2440225f93a}",
            "8": "{4a2f28e3-53b9-4441-ba9c-d69d4a4a6e38}",
            "8.1": "{1f676c76-80e1-4239-95bb-83d0f6d0da78}",
            "10": "{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}",
        }
        for guid in supportedOS_guids.values():
            sosE = doc.cE("supportedOS")
            sosE.setAttribute("Id", guid)
            caE.aChild(sosE)

        cE.aChild(caE)
        docE.aChild(cE)
        return doc

    def toprettyxml(self, indent="  ", newl=os.linesep, encoding="UTF-8"):
        """ Return the manifest as pretty-printed XML """
        domtree = self.todom()
        if sys.version_info >= (2, 3):
            xmlstr = domtree.toprettyxml(indent, newl, encoding)
        else:
            xmlstr = domtree.toprettyxml(indent, newl)
        xmlstr = (
            xmlstr.decode()
            .strip(os.linesep)
            .replace(
                '<?xml version="1.0" encoding="%s"?>' % encoding,
                '<?xml version="1.0" encoding="%s" standalone="yes"?>' % encoding,
            )
        )
        domtree.unlink()
        return xmlstr

    def toxml(self, encoding="UTF-8"):
        """ Return the manifest as XML """
        domtree = self.todom()
        xmlstr = (
            domtree.toxml(encoding)
            .decode()
            .replace(
                '<?xml version="1.0" encoding="%s"?>' % encoding,
                '<?xml version="1.0" encoding="%s" standalone="yes"?>' % encoding,
            )
        )
        domtree.unlink()
        return xmlstr

    def update_resources(self, dstpath, names=None, languages=None):
        """ Update or add manifest resource in dll/exe file dstpath """
        UpdateManifestResourcesFromXML(dstpath, self.toprettyxml(), names, languages)

    def writeprettyxml(
        self, filename_or_file=None, indent="  ", newl=os.linesep, encoding="UTF-8"
    ):
        """ Write the manifest as XML to a file or file object """
        if not filename_or_file:
            filename_or_file = self.filename
        if isinstance(filename_or_file, string_types):
            filename_or_file = open(filename_or_file, "wb")
        xmlstr = self.toprettyxml(indent, newl, encoding)
        filename_or_file.write(xmlstr.encode())
        filename_or_file.close()

    def writexml(
        self, filename_or_file=None, indent="  ", newl=os.linesep, encoding="UTF-8"
    ):
        """ Write the manifest as XML to a file or file object """
        if not filename_or_file:
            filename_or_file = self.filename
        if isinstance(filename_or_file, string_types):
            filename_or_file = open(filename_or_file, "wb")
        xmlstr = self.toxml(encoding)
        filename_or_file.write(xmlstr.encode())
        filename_or_file.close()


def ManifestFromResFile(filename, names=None, languages=None):
    """ Create and return manifest instance from resource in dll/exe file """
    res = GetManifestResources(filename, names, languages)
    pth = []
    if res:
        if res[RT_MANIFEST]:
            while isinstance(res, dict):
                if res.keys():
                    key = res.keys()[0]
                    pth.append(str(key))
                    res = res[key]

    if isinstance(res, dict):
        raise InvalidManifestError(
            "No matching manifest resource found in '%s'" % filename
        )
    manifest = Manifest()
    manifest.filename = (":").join([filename] + pth)
    manifest.parse_string(res, False)
    return manifest


def ManifestFromDOM(domtree):
    """ Create and return manifest instance from DOM tree """
    manifest = Manifest()
    manifest.load_dom(domtree)
    return manifest


def ManifestFromXML(xmlstr):
    """ Create and return manifest instance from XML """
    manifest = Manifest()
    manifest.parse_string(xmlstr)
    return manifest


def ManifestFromXMLFile(filename_or_file):
    """ Create and return manifest instance from file """
    manifest = Manifest()
    manifest.parse(filename_or_file)
    return manifest


def GetManifestResources(filename, names=None, languages=None):
    """ Get manifest resources from file """
    return winresource.GetResources(filename, [RT_MANIFEST], names, languages)


def UpdateManifestResourcesFromXML(dstpath, xmlstr, names=None, languages=None):
    """ Update or add manifest XML as resource in dstpath """
    logger.info("Updating manifest in %s", dstpath)
    if dstpath.lower().endswith(".exe"):
        name = 1
    else:
        name = 2
    winresource.UpdateResources(
        dstpath, xmlstr, RT_MANIFEST, names or [name], languages or [0, "*"]
    )


def UpdateManifestResourcesFromXMLFile(dstpath, srcpath, names=None, languages=None):
    """ Update or add manifest XML from srcpath as resource in dstpath """
    logger.info("Updating manifest from %s in %s", srcpath, dstpath)
    if dstpath.lower().endswith(".exe"):
        name = 1
    else:
        name = 2
    winresource.UpdateResourcesFromDataFile(
        dstpath, srcpath, RT_MANIFEST, names or [name], languages or [0, "*"]
    )


def create_manifest(filename, manifest, console, uac_admin=False, uac_uiaccess=False):
    """
    Create assembly manifest.
    """
    if not manifest:
        manifest = ManifestFromXMLFile(filename)
        name = os.path.basename(filename)
        manifest.name = os.path.splitext(os.path.splitext(name)[0])[0]
    else:
        if isinstance(manifest, string_types):
            if "<" in manifest:
                manifest = ManifestFromXML(manifest)
            if not isinstance(manifest, Manifest):
                manifest = ManifestFromXMLFile(manifest)
    dep_names = set([dep.name for dep in manifest.dependentAssemblies])
    if manifest.filename != filename:
        depmanifest = ManifestFromXMLFile(filename)
        for assembly in depmanifest.dependentAssemblies:
            if assembly.name not in dep_names:
                manifest.dependentAssemblies.append(assembly)
                dep_names.add(assembly.name)

    if not console:
        if "Microsoft.Windows.Common-Controls" not in dep_names:
            manifest.dependentAssemblies.append(
                Manifest(
                    type_="win32",
                    name="Microsoft.Windows.Common-Controls",
                    language="*",
                    processorArchitecture=processor_architecture(),
                    version=(6, 0, 0, 0),
                    publicKeyToken="6595b64144ccf1df",
                )
            )
    if uac_admin:
        manifest.requestedExecutionLevel = "requireAdministrator"
    if uac_uiaccess:
        manifest.uiAccess = True
    need_new = not os.path.exists(filename)
    if not need_new:
        with open(filename) as (f):
            old_xml = f.read()
        new_xml = manifest.toprettyxml().replace("\r", "")
        need_new = old_xml != new_xml
    if need_new:
        manifest.writeprettyxml(filename)
    return manifest


def processor_architecture():
    """
    Detect processor architecture for assembly manifest.
    
    According to:
    http://msdn.microsoft.com/en-us/library/windows/desktop/aa374219(v=vs.85).aspx
    item processorArchitecture in assembly manifest is
    
    'x86' - 32bit Windows
    'amd64' - 64bit Windows
    """
    if architecture() == "32bit":
        return "x86"
    else:
        return "amd64"


if __name__ == "__main__":
    dstpath = sys.argv[1]
    srcpath = sys.argv[2]
    UpdateManifestResourcesFromXMLFile(dstpath, srcpath)
